// pages/appointment/index.js
const appointmentService = require('../../services/appointment');
const util = require('../../utils/util');

Page({

  /**
   * 页面的初始数据
   */
  data: {
    isLoggedIn: false,            // 是否已登录
    isLoading: true,              // 是否正在加载数据
    statusCounts: {               // 各状态预约数量
      pending: 0,                 // 待确认
      confirmed: 0,               // 已确认
      completed: 0,               // 已完成
      cancelled: 0,               // 已取消
    },
    recentAppointments: [],       // 最近预约列表
    appointmentTypes: ['普通就诊', '疫苗接种', '绝育手术', '其他'],  // 预约类型描述
    error: null                   // 错误信息
  },

  /**
   * 生命周期函数--监听页面加载
   */
  onLoad(options) {
    console.log('预约页面加载');
  },

  /**
   * 生命周期函数--监听页面初次渲染完成
   */
  onReady() {

  },

  /**
   * 生命周期函数--监听页面显示
   */
  onShow() {
    this.checkLoginStatus();
  },

  /**
   * 生命周期函数--监听页面隐藏
   */
  onHide() {

  },

  /**
   * 生命周期函数--监听页面卸载
   */
  onUnload() {

  },

  /**
   * 页面相关事件处理函数--监听用户下拉动作
   */
  onPullDownRefresh() {
    this.refreshData(() => {
      wx.stopPullDownRefresh();
    });
  },

  /**
   * 页面上拉触底事件的处理函数
   */
  onReachBottom() {

  },

  /**
   * 用户点击右上角分享
   */
  onShareAppMessage() {
    return {
      title: '宠物医院在线预约',
      path: '/pages/appointment/index'
    };
  },

  /**
   * 检查用户登录状态
   */
  checkLoginStatus() {
    const app = getApp();
    console.log('全局数据:', app.globalData);
    
    // 从globalData或本地存储中获取token
    let token = app.globalData.token;
    if (!token) {
      token = wx.getStorageSync('token');
      if (token) {
        app.globalData.token = token;
      }
    }
    
    const isLoggedIn = !!token;
    console.log('登录状态:', isLoggedIn ? '已登录' : '未登录', 'token:', token);
    
    this.setData({ isLoggedIn });
    
    if (isLoggedIn) {
      console.log('用户已登录，开始获取预约数据');
      this.refreshData();
    } else {
      console.log('用户未登录，显示登录提示');
      this.setData({ isLoading: false });
    }
  },

  /**
   * 刷新页面数据
   */
  refreshData(callback) {
    console.log('开始刷新预约数据');
    this.setData({ 
      isLoading: true,
      error: null 
    });
    
    // 同时请求预约统计和最近预约列表
    Promise.all([
      this.loadAppointmentStats(),
      this.loadRecentAppointments()
    ])
    .then(() => {
      console.log('所有预约数据加载完成');
      this.setData({ isLoading: false });
      callback && callback();
    })
    .catch(err => {
      console.error('加载预约数据失败', err);
      this.setData({ 
        isLoading: false,
        error: err.message || '加载数据失败'
      });
      wx.showToast({
        title: err.message || '加载数据失败',
        icon: 'none'
      });
      callback && callback();
    });
  },

  /**
   * 加载预约状态统计
   */
  loadAppointmentStats() {
    console.log('开始加载预约状态统计');
    return new Promise((resolve, reject) => {
      // 使用列表接口来统计不同状态的预约数量，传入null表示查询所有状态
      appointmentService.getUserAppointments(null, 1, 999)
        .then(res => {
          console.log('获取预约列表成功用于统计:', JSON.stringify(res, null, 2));
          
          // 检查返回的数据结构
          const list = res && res.records ? res.records : [];
          if (Array.isArray(list)) {
            console.log('获取到预约列表数组用于统计, 长度:', list.length);
            
            if (list.length === 0) {
              console.log('预约列表为空，设置所有状态数量为0');
              this.setData({
                statusCounts: {
                  pending: 0,
                  confirmed: 0,
                  completed: 0,
                  cancelled: 0
                }
              });
              resolve();
              return;
            }
            
            // 预处理列表，确保状态值是数字
            const processedList = list.map(item => {
              if (!item) return null;
              
              const status = typeof item.status === 'string' ? parseInt(item.status) : (item.status || 0);
              console.log(`预约ID: ${item.id}, 原始状态: ${item.status}, 处理后状态: ${status}`);
              return {
                ...item,
                status
              };
            }).filter(item => item !== null);
            
            // 计算各状态的数量
            const pending = processedList.filter(item => item.status === 0).length;
            const confirmed = processedList.filter(item => item.status === 1).length;
            const completed = processedList.filter(item => item.status === 2).length;
            const cancelled = processedList.filter(item => item.status === 3).length;
            
            console.log('预约状态统计结果:', {
              pending,
              confirmed,
              completed,
              cancelled,
              total: processedList.length
            });
            
            this.setData({
              statusCounts: {
                pending,
                confirmed,
                completed,
                cancelled
              }
            });
            
            resolve();
          } else {
            console.error('预约列表返回格式错误:', res);
            this.setData({
              statusCounts: {
                pending: 0,
                confirmed: 0,
                completed: 0,
                cancelled: 0
              }
            });
            resolve();
          }
        })
        .catch(err => {
          console.error('获取预约统计失败:', err);
          // 出错时也设置为0
          this.setData({
            statusCounts: {
              pending: 0,
              confirmed: 0,
              completed: 0,
              cancelled: 0
            }
          });
          resolve(); // 不reject，避免整个页面加载失败
        });
    });
  },

  /**
   * 加载最近预约
   */
  loadRecentAppointments() {
    console.log('开始加载最近预约');
    return new Promise((resolve, reject) => {
      // 获取预约列表，按时间排序，确保所有状态的预约都能显示
      appointmentService.getUserAppointments(undefined, 1, 10)
        .then(res => {
          console.log('获取最近预约成功:', JSON.stringify(res, null, 2));
          
          // 检查返回的数据结构
          const list = res && res.records ? res.records : [];
          if (Array.isArray(list)) {
            console.log('获取到最近预约数组, 长度:', list.length);
            
            // 处理预约数据，格式化时间等
            const appointments = list.map(item => {
              console.log('处理预约项:', JSON.stringify(item, null, 2));
              
              // 构建完整的预约对象，确保所有字段都存在
              const appointmentItem = {
                id: item.id,
                userId: item.userId,
                petId: item.petId,
                staffId: item.staffId,
                departmentId: item.departmentId,
                type: item.type !== undefined ? item.type : 0,
                description: item.description || '',
                remark: item.remark || '',
                status: item.status !== undefined ? (typeof item.status === 'string' ? parseInt(item.status) : item.status) : 0,
                
                // 确保petName字段存在，可能来自item.petName或item.extraData?.petName
                petName: item.petName || (item.extraData && item.extraData.petName) || '未知宠物',
                
                // 确保staffName字段存在，可能来自item.staffName或item.extraData?.staffName
                staffName: item.staffName || (item.extraData && item.extraData.staffName) || '未知医生',
                
                // 确保departmentName字段存在，可能来自item.departmentName或item.extraData?.departmentName
                departmentName: item.departmentName || (item.extraData && item.extraData.departmentName) || '未知科室',
                
                // 处理日期时间
                appointmentTime: item.appointmentTime ? util.formatDateTime(new Date(item.appointmentTime)) : '未设置',
                createTime: item.createTime ? util.formatDate(new Date(item.createTime)) : '未设置',
                updateTime: item.updateTime ? util.formatDate(new Date(item.updateTime)) : '未设置'
              };
              
              console.log('处理后的预约项:', JSON.stringify(appointmentItem, null, 2));
              return appointmentItem;
            });
            
            console.log('格式化后的预约列表:', JSON.stringify(appointments, null, 2));
            
            // 按状态统计预约数量（仅作为日志记录，实际统计在loadAppointmentStats中）
            const statusCounts = {
              pending: appointments.filter(item => item.status === 0).length,
              confirmed: appointments.filter(item => item.status === 1).length,
              completed: appointments.filter(item => item.status === 2).length,
              cancelled: appointments.filter(item => item.status === 3).length
            };
            console.log('最近预约状态统计:', statusCounts);
            
            this.setData({
              recentAppointments: appointments
            });
            
            resolve();
          } else {
            console.error('最近预约返回格式错误:', res);
            reject(new Error('获取最近预约格式错误'));
          }
        })
        .catch(err => {
          console.error('获取最近预约失败:', err);
          reject(err);
        });
    });
  },

  /**
   * 导航到登录页
   */
  navigateToLogin() {
    wx.navigateTo({
      url: '/pages/login/login'
    });
  },

  /**
   * 导航到添加预约页
   */
  navigateToAddAppointment() {
    if (!this.data.isLoggedIn) {
      wx.showToast({
        title: '请先登录',
        icon: 'none'
      });
      setTimeout(() => {
        this.navigateToLogin();
      }, 1500);
      return;
    }
    
    wx.navigateTo({
      url: '/pages/appointment/add'
    });
  },

  /**
   * 导航到预约列表页
   */
  navigateToAppointmentList() {
    if (!this.data.isLoggedIn) {
      wx.showToast({
        title: '请先登录',
        icon: 'none'
      });
      setTimeout(() => {
        this.navigateToLogin();
      }, 1500);
      return;
    }
    
    wx.navigateTo({
      url: '/pages/appointment/list'
    });
  },

  /**
   * 根据状态导航到预约列表
   */
  navigateToAppointmentListWithStatus(e) {
    if (!this.data.isLoggedIn) {
      wx.showToast({
        title: '请先登录',
        icon: 'none'
      });
      setTimeout(() => {
        this.navigateToLogin();
      }, 1500);
      return;
    }
    
    const status = e.currentTarget.dataset.status;
    wx.navigateTo({
      url: `/pages/appointment/list?status=${status}`
    });
  },

  /**
   * 导航到预约详情
   */
  navigateToDetail(e) {
    const id = e.currentTarget.dataset.id;
    wx.navigateTo({
      url: `/pages/appointment/detail?id=${id}`
    });
  },

  /**
   * 导航到科室页面
   */
  navigateToDepartments() {
    wx.navigateTo({
      url: '/pages/hospital/departments'
    });
  },

  /**
   * 导航到医生页面
   */
  navigateToDoctor() {
    wx.navigateTo({
      url: '/pages/hospital/doctors'
    });
  }
})